home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d13 / pproject.arc / ACTIVITY.CLS < prev    next >
Encoding:
Text File  |  1990-06-07  |  10.9 KB  |  419 lines
  1. /* Activity is a formal class to group common behavior among
  2.    tasks and milestones for projects.  Activities know how to
  3.    determine if they are on the critical path and keep track
  4.    of their earlyStart, lateFinish and slack time.
  5.    The user can set an earlyStart or lateFinish to override
  6.    what is calculated.
  7.  
  8.    Since Activity descends from Node, it inherits all of the
  9.    methods and instance variables from Node, e.g. name, desc,
  10.    inputs, outputs, etc.
  11. */!!
  12.  
  13. inherit(Node, #Activity, #(earlyStart     /* calculated */ 
  14. lateFinish     /* calculated */
  15. userEarlyStart /* user entered */
  16. userLateFinish /* user entered */
  17. slack          /* slack time */
  18. critical       /* boolean */), 2, nil)!!
  19.  
  20. now(ActivityClass)!!
  21.  
  22. now(Activity)!!
  23.  
  24. /* Return the class name.  Generic version.
  25.    Ancestors will redefine this to use resources. */
  26. Def className(self)
  27. {
  28.   ^asString(class(self));
  29. }!!
  30.  
  31. /* Return true if the activity is "complete", e.g.
  32.    connected.  Descendants may redefine this.
  33.    This is for experimental use only.   */
  34. Def  complete(self)
  35. { 
  36.   ^size(inputs) + size(outputs) > 0;
  37. }!!
  38.  
  39. /* In general, activities place no limit on the number
  40.    of connections.  Descendants, such as Task, will
  41.    redefine this to place limits. */
  42. Def  maxConnectionNames(self, names)
  43. { 
  44.   ^names;
  45. }!!
  46.  
  47. /* Delete an activity.  First check to see if it is
  48.    connected to anything and check with the user. */
  49. Def  delete(self)
  50. { 
  51.   if size(inputs) + size(outputs) = 0
  52.     cor yesNoBox(loadString(PW_WARNING),
  53.                  name + loadString(PW_ACTUSE1) +
  54.                  loadString(PW_ACTUSE2) + CR_LF +
  55.                  loadString(PW_DELETE)) == IDYES
  56.      do(inputs,
  57.        {using(input)
  58.         disconnect(input, self);
  59.      });
  60.      do(outputs,
  61.        {using(output)
  62.         disconnect(self, output);
  63.      });
  64.      removeNode(network, self);
  65.      remove(network.display, pos(self));
  66.   endif;      
  67. }!!
  68.  
  69. /* Parse a string of nodeNames and return a set of
  70.    nodes.  Checks to see if they exist.  */
  71. Def  parseNodeNames(self, nodeNames | names, nodes, aNode)
  72. {
  73.   names := words(nodeNames);
  74.   names := maxConnectionNames(self, names);
  75.   nodes := new(OrderedCollection, 5);
  76.   do(names,
  77.     {using(name) 
  78.      if aNode := checkNodeExists(network, name)
  79.         add(nodes, aNode);
  80.      endif;
  81.   });
  82.   ^nodes;
  83. }!!
  84.  
  85. /* Checks the connections and reconnects if necessary. 
  86.    If the connections change, we may have to recalc
  87.    the entire project. */
  88. Def  checkConnection(self, inputsString, outputsString
  89.                      | newInputs, newOutputs, calcReqd)
  90. {  
  91.   if inputsString <> getInputNames(self)
  92.     newInputs := parseNodeNames(self, inputsString);
  93.     do(inputs,
  94.       {using(input)
  95.        if not(input in newInputs)
  96.           disconnect(network, input.name, self.name); 
  97.           calcReqd := true;
  98.        endif;
  99.      });
  100.     do(newInputs,
  101.       {using(input)
  102.        if not(input in inputs)
  103.         connect(network, input.name, self.name); 
  104.         calcReqd := true;
  105.        endif;
  106.      });
  107.    endif;
  108.  
  109.   if outputsString <> getOutputNames(self)
  110.     newOutputs := parseNodeNames(self, outputsString);   
  111.     do(outputs,
  112.       {using(output)
  113.        if not(output in newOutputs)
  114.          disconnect(network, self.name, output.name); 
  115.          calcReqd := true;
  116.        endif
  117.      });
  118.     do(newOutputs,
  119.       {using(output)
  120.        if not(output in outputs)
  121.          connect(network, self.name, output.name); 
  122.          calcReqd := true;
  123.        endif;
  124.      });
  125.   endif;            
  126.   
  127.   if autoCalc(network) cand calcReqd
  128.     recalc(network)
  129.   endif;
  130. }!!
  131.  
  132. /* Return a string of output names. 
  133.    This is useful when editing. */
  134. Def  getOutputNames(self | str)
  135. {
  136.   str := "";
  137.   do(outputs,
  138.     {using(output) str := str + getName(output) + " ";
  139.   });
  140.   ^str;
  141. }!!
  142.  
  143. /* Return a string of input names. 
  144.    This is useful when editing. */
  145. Def  getInputNames(self | str)
  146. {
  147.   str := "";
  148.   do(inputs,
  149.     {using(input) str := str + getName(input) + " ";
  150.   });
  151.   ^str;
  152. }!!
  153.  
  154. /* Display and edit the activity information. 
  155.    Descendants that use this should have a dialogClass()
  156.    method that returns the dialog class to be used. The
  157.    dialog class should define methods run() and setEditItem().
  158. */
  159. Def  editInfo(self | dlg, retValue)
  160. {
  161.   showWaitCurs();              /* this can take a while */
  162.   dlg := new(dialogClass(self));
  163.   setEditItem(dlg, self);
  164.   retValue := run(dlg, ThePort);
  165.   showOldCurs();               /* all done */
  166.   ^retValue;
  167. }!!
  168.  
  169. /* In the simplest case an activity is critical if slack = 0.
  170.    However, if the user has set the lateFinish, it could
  171.    introduce excess slack to the project.  Therefore, a node
  172.    is  critical if its slack is equal to the excess slack. */
  173. Def  calcCritical(self)
  174. { 
  175.   critical := (slack = getSlack(network));
  176. }!!
  177.  
  178. /* Set the values of an activity. 
  179.    Values is an array of name, desc,
  180.    userEarlyStart, userLateFinish. */
  181. Def  setValues(self, values | oldUES, oldULF)
  182. {
  183.   oldUES := userEarlyStart;
  184.   oldULF := userLateFinish;
  185.   name := values[0];
  186.   desc := values[1];
  187.   userEarlyStart := values[2];
  188.   userLateFinish := values[3];
  189.   if autoCalc(network) cand 
  190.      (oldUES <> userEarlyStart cor
  191.       oldULF <> userLateFinish)
  192.     recalc(self);
  193.   endif;
  194. }!!
  195.  
  196. /* Get the user set earlyStart time. */
  197. Def  getUserEarlyStart(self)
  198. { 
  199.  ^userEarlyStart;
  200. }!!
  201.  
  202. /* Get the user set lateFinish time. */
  203. Def  getUserLateFinish(self)
  204. { 
  205.  ^userLateFinish;
  206. }!!
  207.  
  208. /* Return a string to be used as a caption in a window. */
  209. Def  makeCaption(self)
  210. {
  211.   ^className(self) + ": "+getName(self)+
  212.    if critical(self)
  213.       loadString(PW_CRITICAL)
  214.    else
  215.       loadString(PW_NONCRITICAL)
  216.    endif;
  217. }!!
  218.  
  219. /* Summarize useful information on a single line. */
  220. Def  getInfoLine(self | str)
  221. {
  222.   if critical(self)
  223.     str := "*";
  224.   else
  225.     str := " ";
  226.   endif;
  227.   ^str + field(name, 8) 
  228.    + field(className(self), 4) + " "
  229.    + field(asString(getCost(self)), 3) + " "
  230.    + field(asString(getTime(self)), 2) + " " 
  231.    + field(asString(getSlack(self)), 3) + " " 
  232.    + field(asString(getEarlyStart(self)), 8) + " "
  233.    + field(asString(getLateFinish(self)), 8);
  234. }!!
  235.  
  236. /* Get the lateFinish time.  At End, lateFinish = earlyStart,
  237.    unless the user set a lateFinish. */
  238. Def  getLateFinish(self)
  239. { 
  240.   if (size(outputs) == 0 and not(userLateFinish))
  241.     lateFinish := earlyStart
  242.   endif;
  243.  ^lateFinish;
  244. }!!
  245.  
  246. /* Calculate slack for an Activity.  This is done
  247.    on the backward recalc pass when ES, LF are
  248.    up to date.  Slack is never < 0. */
  249. Def  calcSlack(self)
  250. {  
  251.   ^slack := max(0, getLateStart(self) - getEarlyStart(self));
  252. }!!
  253.  
  254. /* Get the slack value.  */
  255. Def getSlack(self)
  256. {
  257.   ^slack;
  258. }!!
  259.  
  260. /* Return the status of whether the node is critical or not. */
  261. Def  critical(self)
  262. { 
  263.   ^critical;
  264. }!!
  265.  
  266. /* Invalidate a node and recursively invalidate all
  267.    nodes it's connected to.  This is used to force
  268.    an entire recalc of the network. */
  269. Def invalidate(self, visited)
  270. {
  271.  reset(self);                      /* reset ivars */
  272.  do(outputs,                       /* pass along */
  273.     {using(elem)
  274.      if not(elem in visited)       /* avoid looping */
  275.         add(visited, elem);
  276.         invalidate(elem, visited); /* recurse */
  277.      endif;
  278.   });
  279. }!!
  280.  
  281. /* Recalculate the network from this node onwards.
  282.    This requires forcing a forward recalc1 and a
  283.    backwards recalc2 from the end of the net. */
  284. Def  recalc(self)
  285. {
  286.   recalc1(self,true);      /* force forward recalc1 */
  287.   recalc2(network);        /* do backwards recalc2 */
  288. }!!
  289.  
  290. /* Backward recalc pass:  (not optimized)
  291.    Recalculate an activity's lateFinish then its slack and
  292.    determine if it's critical.
  293.    If the user has set a lateFinish, use it instead of
  294.    recalculating.  Always propogate recalc2 since a
  295.    change to the time of a node will not change lateFinish,
  296.    but it can change slack and critical, which are only
  297.    known on the backwards pass.
  298.    
  299.    formula:  LF = min(LF(i) - time(i)) for all outputs i
  300.    
  301.    Note: This could be optimized to only propogate recalc2
  302.    as far back as the next Milestone.  */
  303. Def  recalc2(self)
  304. {  
  305.   if (userLateFinish)
  306.     lateFinish := userLateFinish;   /* user override */
  307.   else
  308.     lateFinish := asLong(date(12,31,1999));
  309.     do(outputs,
  310.       {using(output)
  311.       lateFinish := min(lateFinish, 
  312.                          getLateFinish(output) - getTime(output));
  313.     });
  314.     lateFinish := asDate(lateFinish);
  315.   endif;
  316.   
  317.   calcSlack(self);
  318.   calcCritical(self);
  319.  
  320.   /* Continue sending the recalc2 message. */
  321.  
  322.   do(inputs,
  323.     {using(input)
  324.     recalc2(input);
  325.   });
  326. }!!
  327.  
  328. /* Forward recalc pass: (optimized minimal recalc)
  329.    Recalculate an activity's earlyStart.  If the user has
  330.    set an earlyStart, use it instead of recalculating.
  331.    Send a message to the node's outputs to recalculate only
  332.    if a forced recalc is required, or if earlyStart changes.
  333.    
  334.    formula:  ES = max(ES(i) + time(i)) for all inputs i
  335.  
  336.    arguments:
  337.      timeChanged: force a recalc1 if the time has changed
  338. */
  339. Def  recalc1(self, timeChanged | oldEarlyStart)
  340. {   
  341.   oldEarlyStart := earlyStart;
  342.  
  343.   if (userEarlyStart)
  344.     earlyStart := userEarlyStart;     /* user override */
  345.   else
  346.     earlyStart := asLong(new(Date));    
  347.     do(inputs,
  348.       {using(input) 
  349.       earlyStart := max(earlyStart,
  350.                      getEarlyStart(input) + getTime(input));                 
  351.     });
  352.     earlyStart := asDate(earlyStart);
  353.   endif;
  354.   
  355.   /* Recalculate outputs only if earlyStart changed OR if time has
  356.      changed.  Don't force it to continue beyond the next level.  */
  357.  
  358.   if timeChanged cor (earlyStart <> oldEarlyStart)   
  359.     do(outputs,
  360.       {using(output) recalc1(output, nil);
  361.     });
  362.   endif;
  363. }!!
  364.  
  365. /* Initialize a new Activity. */
  366. Def  init(self)
  367. { init(self:Node);        /* use ancestor init */
  368.   reset(self);            /* reset ivars */
  369. } !!
  370.  
  371. /* Reset the instance variables. This is called by
  372.    init and when an entire recalc is forced. */
  373. Def reset(self)
  374. {
  375.   slack := 0;
  376.   lateFinish := earlyStart := new(Date);
  377.   critical := nil;
  378. }!!
  379.  
  380. /* The user can enter a late finish date to be used
  381.    instead of the calculated value. */
  382. Def  setLateFinish(self, aDate)
  383. { 
  384.   userLateFinish := aDate;
  385.   if autoCalc(network)        /* just do backwards calc */
  386.      recalc2(network);
  387.   endif;
  388. }!!
  389.  
  390. /* The user can enter an early start date to be used
  391.    instead of the calculated value. */
  392. Def  setEarlyStart(self, aDate)
  393. { 
  394.   userEarlyStart := aDate;
  395.   if autoCalc(network)
  396.     recalc(self);
  397.   endif;
  398. } !!
  399.  
  400. /* Get the earlyStart time. */
  401. Def  getEarlyStart(self)
  402. { 
  403.  ^earlyStart;
  404. } !!
  405.  
  406. /* Calculcate the earlyFinish time. */
  407. Def  getEarlyFinish(self)
  408. { 
  409.  ^asDate(getEarlyStart(self) + getTime(self));
  410. }!!
  411.  
  412. /* Calcualate the lateStart time. */
  413. Def  getLateStart(self)
  414. { 
  415.  ^asDate(getLateFinish(self) - getTime(self));
  416. }!!
  417.  
  418.  
  419.